#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
MCP2 记忆模式启动脚本

本脚本用于启动MCP2项目的记忆模式，包括：
1. 验证系统配置
2. 初始化数据库连接
3. 创建初始记忆和对话
4. 启动MCP服务
5. 提供记忆模式管理功能
"""

import asyncio
import sys
import os
import yaml
from pathlib import Path
from datetime import datetime
from loguru import logger

# 添加项目根目录到Python路径
project_root = Path(__file__).parent
sys.path.insert(0, str(project_root))

try:
    from src.config import load_config
    from src.database.manager import DatabaseManager
    from src.core.memory_manager import MemoryManager
    from src.core.conversation_manager import ConversationManager
    from src.core.knowledge_processor import KnowledgeProcessor
    from src.mcp.server import MCPServer
except ImportError as e:
    print(f"导入模块失败: {e}")
    print("请确保项目依赖已正确安装")
    sys.exit(1)


class MemoryModeManager:
    """记忆模式管理器"""
    
    def __init__(self):
        self.config = None
        self.memory_config = None
        self.db_manager = None
        self.memory_manager = None
        self.conversation_manager = None
        self.knowledge_processor = None
        self.mcp_server = None
        self.is_initialized = False
    
    async def initialize(self):
        """初始化记忆模式"""
        try:
            logger.info("开始初始化记忆模式...")
            
            # 1. 加载配置
            await self._load_configurations()
            
            # 2. 验证配置
            await self._validate_configurations()
            
            # 3. 初始化数据库
            await self._initialize_databases()
            
            # 4. 初始化管理器
            await self._initialize_managers()
            
            # 5. 创建初始记忆
            await self._create_initial_memory()
            
            # 6. 初始化MCP服务器
            await self._initialize_mcp_server()
            
            self.is_initialized = True
            logger.info("记忆模式初始化完成")
            
        except Exception as e:
            logger.error(f"记忆模式初始化失败: {e}")
            raise
    
    async def _load_configurations(self):
        """加载配置文件"""
        logger.info("加载配置文件...")
        
        # 加载主配置
        self.config = load_config()
        
        # 加载记忆模式配置
        memory_config_path = project_root / 'config' / 'memory_mode.yaml'
        if memory_config_path.exists():
            with open(memory_config_path, 'r', encoding='utf-8') as f:
                self.memory_config = yaml.safe_load(f)
        else:
            logger.warning("记忆模式配置文件不存在，使用默认配置")
            self.memory_config = self._get_default_memory_config()
    
    def _get_default_memory_config(self):
        """获取默认记忆模式配置"""
        return {
            'memory_mode': {
                'enabled': True,
                'project': {
                    'name': 'MCP2',
                    'type': 'long_term_development',
                    'start_date': datetime.now().strftime('%Y-%m-%d')
                },
                'strategy': {
                    'auto_memory_important_events': True,
                    'importance_threshold': 0.7,
                    'auto_conversation_summary': True
                }
            }
        }
    
    async def _validate_configurations(self):
        """验证配置"""
        logger.info("验证配置...")
        
        # 验证主配置
        if not self.config:
            raise ValueError("主配置加载失败")
        
        # 验证记忆模式配置
        if not self.memory_config.get('memory_mode', {}).get('enabled', False):
            raise ValueError("记忆模式未启用")
        
        logger.info("配置验证通过")
    
    async def _initialize_databases(self):
        """初始化数据库连接"""
        logger.info("初始化数据库连接...")
        
        self.db_manager = DatabaseManager(self.config)
        await self.db_manager.connect_all()
        
        # 验证数据库连接
        connections = {
            'MongoDB': await self.db_manager.mongodb_client.ping() if self.db_manager.mongodb_client else False,
            'Redis': await self.db_manager.redis_client.ping() if self.db_manager.redis_client else False,
            'Neo4j': await self.db_manager.neo4j_client.ping() if self.db_manager.neo4j_client else False,
            'ChromaDB': await self.db_manager.chromadb_client.ping() if self.db_manager.chromadb_client else False
        }
        
        connected_dbs = [db for db, status in connections.items() if status]
        logger.info(f"数据库连接状态: {connected_dbs}")
        
        if not any(connections.values()):
            raise RuntimeError("所有数据库连接都失败")
    
    async def _initialize_managers(self):
        """初始化管理器"""
        logger.info("初始化管理器...")
        
        self.memory_manager = MemoryManager(self.db_manager, self.config)
        await self.memory_manager.initialize()
        
        self.conversation_manager = ConversationManager(self.db_manager, self.config)
        await self.conversation_manager.initialize()
        
        self.knowledge_processor = KnowledgeProcessor(self.db_manager, self.config)
        await self.knowledge_processor.initialize()
    
    async def _create_initial_memory(self):
        """创建初始记忆"""
        logger.info("创建初始记忆...")
        
        project_info = self.memory_config['memory_mode']['project']
        
        # 创建项目启动记忆
        memory_content = f"""
        记忆模式启动记录:
        
        项目名称: {project_info['name']}
        项目类型: {project_info['type']}
        启动时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
        
        记忆模式已成功启动，系统将自动记录和管理开发过程中的重要信息。
        包括代码变更、设计决策、问题解决方案、学习笔记等。
        
        系统配置:
        - 自动记忆重要事件: 启用
        - 重要性阈值: {self.memory_config['memory_mode']['strategy']['importance_threshold']}
        - 自动对话摘要: 启用
        """
        
        try:
            memory_id = await self.memory_manager.create_memory(
                user_id='default_user',
                content=memory_content,
                memory_type='episodic',
                importance=0.9,
                tags=['记忆模式', '项目启动', project_info['name'], '系统初始化']
            )
            logger.info(f"初始记忆创建成功，ID: {memory_id}")
        except Exception as e:
            logger.warning(f"初始记忆创建失败: {e}")
    
    async def _initialize_mcp_server(self):
        """初始化MCP服务器"""
        logger.info("初始化MCP服务器...")
        
        try:
            self.mcp_server = MCPServer(
                config=self.config,
                db_manager=self.db_manager
            )
            logger.info("MCP服务器初始化完成")
        except Exception as e:
            logger.warning(f"MCP服务器初始化失败: {e}")
    
    async def start_memory_mode(self):
        """启动记忆模式"""
        if not self.is_initialized:
            await self.initialize()
        
        logger.info("启动记忆模式服务...")
        
        # 显示启动信息
        self._display_startup_info()
        
        # 启动MCP服务器（如果可用）
        if self.mcp_server:
            try:
                await self.mcp_server.start()
            except Exception as e:
                logger.warning(f"MCP服务器启动失败: {e}")
        
        logger.info("记忆模式已启动，系统准备就绪")
    
    def _display_startup_info(self):
        """显示启动信息"""
        project_info = self.memory_config['memory_mode']['project']
        
        print("\n" + "="*60)
        print("MCP2 记忆模式已启动")
        print("="*60)
        print(f"项目名称: {project_info['name']}")
        print(f"项目类型: {project_info['type']}")
        print(f"启动时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print("\n功能状态:")
        print("  ✓ 记忆管理系统")
        print("  ✓ 对话历史管理")
        print("  ✓ 知识处理系统")
        print("  ✓ 多数据库支持")
        if self.mcp_server:
            print("  ✓ MCP协议服务")
        print("\n记忆模式特性:")
        print("  • 自动记忆重要事件")
        print("  • 智能上下文管理")
        print("  • 语义搜索和检索")
        print("  • 知识图谱构建")
        print("  • 长期记忆保持")
        print("\n" + "="*60)
    
    async def stop_memory_mode(self):
        """停止记忆模式"""
        logger.info("停止记忆模式...")
        
        # 停止MCP服务器
        if self.mcp_server:
            try:
                await self.mcp_server.stop()
            except Exception as e:
                logger.warning(f"MCP服务器停止失败: {e}")
        
        # 关闭数据库连接
        if self.db_manager:
            await self.db_manager.close_all()
        
        logger.info("记忆模式已停止")
    
    async def get_memory_stats(self):
        """获取记忆统计信息"""
        if not self.is_initialized:
            return None
        
        try:
            stats = {
                'timestamp': datetime.now().isoformat(),
                'project': self.memory_config['memory_mode']['project'],
                'database_status': {},
                'memory_counts': {},
                'conversation_counts': {},
                'knowledge_counts': {}
            }
            
            # 数据库状态
            if self.db_manager:
                stats['database_status'] = {
                    'mongodb': await self.db_manager.mongodb_client.ping() if self.db_manager.mongodb_client else False,
                    'redis': await self.db_manager.redis_client.ping() if self.db_manager.redis_client else False,
                    'neo4j': await self.db_manager.neo4j_client.ping() if self.db_manager.neo4j_client else False,
                    'chromadb': await self.db_manager.chromadb_client.ping() if self.db_manager.chromadb_client else False
                }
            
            return stats
            
        except Exception as e:
            logger.error(f"获取记忆统计信息失败: {e}")
            return None


async def main():
    """主函数"""
    # 配置日志
    logger.add(
        "logs/memory_mode.log",
        rotation="1 day",
        retention="30 days",
        level="INFO",
        format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {name}:{function}:{line} - {message}"
    )
    
    # 创建记忆模式管理器
    memory_mode = MemoryModeManager()
    
    try:
        # 启动记忆模式
        await memory_mode.start_memory_mode()
        
        # 保持运行状态
        print("\n记忆模式正在运行中...")
        print("按 Ctrl+C 停止服务")
        
        # 等待中断信号
        try:
            while True:
                await asyncio.sleep(1)
        except KeyboardInterrupt:
            print("\n收到停止信号...")
        
    except Exception as e:
        logger.error(f"记忆模式运行失败: {e}")
        print(f"错误: {e}")
    
    finally:
        # 停止记忆模式
        await memory_mode.stop_memory_mode()
        print("记忆模式已停止")


def run_memory_mode():
    """运行记忆模式"""
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("\n程序被用户中断")
    except Exception as e:
        print(f"程序运行失败: {e}")
        sys.exit(1)


if __name__ == '__main__':
    run_memory_mode()